home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
United Public Domain Gold 2
/
United Public Domain Gold 2.iso
/
utilities
/
pu745.dms
/
pu745.adf
/
GLOBE099.LHA
/
Ami-Globe
/
read_bin.c
< prev
next >
Wrap
C/C++ Source or Header
|
1994-11-17
|
17KB
|
578 lines
/************************************************************************/
/* */
/* fichier : read_bin.c */
/* projet : amiglobe */
/* date création : 27/08/94 */
/* commentaire : lecture des fichiers new_lac.Pt_bin */
/* création du tableau des points */
/* révision : $VER: read_bin.c 1.002 (27 Aug 1994) */
/* copyright : Olivier Collard, Thomas Landspurg */
/* */
/************************************************************************/
/************************************************************************/
/* includes */
/************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <exec/types.h>
#include <stat.h>
#include <libraries/dos.h>
#include <clib/dos_protos.h>
#include "amiglobe_types.h"
#include "read_bin.h"
#include "database_types.h"
#include "map_function_protos.h"
#include "map_function_types.h"
#include "database_protos.h"
/************************************************************************/
/* defines */
/************************************************************************/
#define NB_MAX_PT_LIGNE 7000 /* Defini le nombre maximum de pt dans un segment */
/* , utilise lors de read map seulement */
/************************************************************************/
/* variables externes */
/************************************************************************/
extern CLIP clip_max;
extern BORDER *tab_vect;
extern BPTR bptr_big;
extern int max_border;
extern int max_country; /* Nombre max de pays */
extern COUNTRY *tab_country;
short int * tableau=NULL;
int taille_tableau=0;
/*********************************************************** read_map() ***/
BOOL
read_map(char *p_filename)
{
char Buffer_Name[100];
FILE *input;
int x, y,code;
char c1,c2,c;
int mx,my,MX,MY;
int i;
int flg_border,flg_zone;
int flg_end;
int num_bord;
int Last_Code=0;
/* Vecteur courant */
struct vect *tab_v;
struct vect *v;
int nb_vect;
BOOL Flg_Err=TRUE;
flg_end=FALSE;
sprintf(Buffer_Name,"%s.pt",p_filename);
if (input = fopen(Buffer_Name,"r"))
{
/* On alloue la mémoire pour le buffer de lecture ligne */
tab_v=(VECT *)malloc((NB_MAX_PT_LIGNE)*sizeof(struct vect));
/* Premiere chose, la taille max de notre carte...*/
fscanf(input,"%ld%ld%ld%ld",
&clip_max.minx,&clip_max.miny,
&clip_max.maxx,&clip_max.maxy);
/* Pref.clip_cur=clip_max;*/
/********************************************************/
/* Puis la liste des bords de pays. C'est une liste */
/* de points terminee par le couple -1 -1 */
/********************************************************/
num_bord=0;
flg_zone=TRUE;
do
{
#ifdef TOMDEBUG
printf("Vecteur numero:%d\n",num_bord);
#endif
v=tab_v;
/* Lecture de composantes d'un bord */
mx=100000;
my=100000;
MX=-100000;
MY=-100000;
flg_border=TRUE;
nb_vect=0;
do
{
c1=getc(input);
c2=getc(input);
if(c2=='#')
{
do
{
c=getc(input);
} while((c!=0x0a)&&(c!=EOF));
flg_border=FALSE;
}
else
{
ungetc(c2,input);
ungetc(c1,input);
fscanf(input,"%ld %ld %ld",&code,&x,&y);
v->x=x;
v->y=-y;
v->Code=code;
tstpt(v->x,v->y,&mx,&my,&MX,&MY);
/* printf("x:%d y:%d -> :%ld %ld\n",x,y,v->x,v->y);
*/
v++;
nb_vect++;
}
if(nb_vect>=NB_MAX_PT_LIGNE)
{
printf("Error :max number of pt exceeded -> %d \n",num_bord);
flg_border=FALSE;
}
} while(flg_border==TRUE);
/* On s'assure que le dernier point est bien de niveau 5 */
if (nb_vect>1)
v[-1].Code=5;
/* On s'assure que le code ud premier pt est bien */
/* un indicateur de nveau segment */
if(tab_v[0].Code<1000)
{
tab_v[0].Code=Last_Code;
}
Last_Code=tab_v[0].Code;
tab_vect[num_bord].p_vect=(VECT *)malloc((nb_vect+10)*
sizeof(struct vect));
for(i=0;i<nb_vect;i++)
{
tab_vect[num_bord].p_vect[i]=tab_v[i];
}
tab_vect[num_bord].b_clip.minx=mx;
tab_vect[num_bord].b_clip.miny=my;
tab_vect[num_bord].b_clip.maxx=MX;
tab_vect[num_bord].b_clip.maxy=MY;
/* printf(" Il y a eu:%d pt dans le bord %d\n",nb_vect,num_bord);
printf("Code:%d Numero:%d\n",tab_v[0].Code,num_bord);
*/
tab_vect[num_bord].nb_vect=nb_vect;
if(num_bord>MAX_BORDER)
{
printf("ERREUR, max number of border exceeded!\n");
}
else
{
num_bord++;
}
if(tst_end(input)==TRUE)
{
flg_zone=FALSE;
}
} while(flg_zone==TRUE);
Flg_Err=FALSE;
max_border=num_bord;
free(tab_v);
}
return(Flg_Err);
}
/*********************************************************** read_map() ***/
BOOL
read_map_bin(char *p_filename)
{
char Buffer_Name[100];
char Buffer_Name_Big[100];
FILE *input;
int mx,my,MX,MY;
int i;
int flg_zone;
int flg_end;
int num_bord;
int Last_Code=0;
/* Vecteur courant */
short int *tab_temp;
char *p_deb;
struct vect *v;
short int nb_vect;
int nb_read,taille;
struct stat my_stat;
short int minx_real,miny_real,maxx_real,maxy_real;
BOOL Flg_Err=TRUE;
flg_end=FALSE;
sprintf(Buffer_Name,"%s.pt_bin_small",p_filename);
sprintf(Buffer_Name_Big,"%s.pt_bin",p_filename);
if ((input = fopen(Buffer_Name,"r"))
&&(bptr_big=Open(Buffer_Name_Big,MODE_OLDFILE)))
{
/* Premiere chose, la taille max de notre carte...*/
fread(&minx_real,sizeof(short int),1,input);
fread(&miny_real,sizeof(short int),1,input);
fread(&maxx_real,sizeof(short int),1,input);
fread(&maxy_real,sizeof(short int),1,input);
clip_max.minx=minx_real;
clip_max.miny=miny_real;
clip_max.maxx=maxx_real;
clip_max.maxy=maxy_real;
/* clip_cur=clip_max;*/
stat(Buffer_Name,&my_stat);
taille=my_stat.st_size;
taille=taille-4*sizeof(short int);
tab_temp=(short int *)malloc(taille);
tableau=tab_temp;
taille_tableau=taille;
if (tab_temp==NULL)
{
printf("ERROR: Not Enough Memory!\n");
}
else
{
nb_read=fread(tab_temp,1,taille,input);
/* lecture du reste du fichier */
if (nb_read!=taille)
{
printf("ERROR: File truncated\n");
}
p_deb=(char *)tab_temp;
num_bord=0;
flg_zone=TRUE;
do
{
#ifdef TOMDEBUG
printf("Vecteur numero:%d\n",num_bord);
#endif
/* Lecture de composantes d'un bord */
mx=100000;
my=100000;
MX=-100000;
MY=-100000;
/* Recupere la position ds le grand fichier */
tab_vect[num_bord].offset=*((LONG *)tab_temp);
tab_vect[num_bord].p_vect_maxres=NULL;
tab_vect[num_bord].nb_vect_bis=-1;
tab_temp+=sizeof(LONG)/sizeof(short int);
nb_vect=*tab_temp++;/* 5eme mot = nb de vecteurs */
tab_vect[num_bord].p_vect=(struct vect *)tab_temp;
tab_temp+=nb_vect*3;
v=tab_vect[num_bord].p_vect;
/* On cree la zone de clipping, mais en */
/* excluant les lacs et rivieres */
for (i=0;i<nb_vect;i++)
{
tstpt(v->x,v->y,&mx,&my,&MX,&MY);
v++;
}
v=tab_vect[num_bord].p_vect;
/* On s'assure que le dernier point est bien de niveau 5 */
if (nb_vect>1)
v[nb_vect-1].Code=5;
/* On s'assure que le code du premier pt est bien */
/* un indicateur de nouveau segment */
if (tab_vect[num_bord].p_vect[0].Code<1000)
{
tab_vect[num_bord].p_vect[0].Code=Last_Code;
}
Last_Code=tab_vect[num_bord].p_vect[0].Code;
tab_vect[num_bord].nb_vect=nb_vect;
tab_vect[num_bord].b_clip.minx=mx;
tab_vect[num_bord].b_clip.miny=my;
tab_vect[num_bord].b_clip.maxx=MX;
tab_vect[num_bord].b_clip.maxy=MY;
/*
printf(" Il y a eu:%d pt dans le bord %d\n",nb_vect,num_bord);
*/
if (num_bord>MAX_BORDER)
{
printf("ERROR, max number of border exceeded!\n");
}
else
{
num_bord++;
}
if ((char *)tab_temp>=taille+p_deb)
{
flg_zone=FALSE;
}
} while(flg_zone==TRUE);
max_border=num_bord;
Flg_Err=FALSE;
}
}
return Flg_Err;
}
/*********************************************************** read_zones() ***/
BOOL
read_zones(char *p_filename, struct RastPort *rpG)
/* lecture du fichier .zones */
/// "read_zones"
{
FILE *input;
int mx,my,MX,MY;
/* struct RastPort *r;*/
BOOL Flg_Err;
char str[100];
char *P_Temp;
char Buffer_Name[100];
int flg_country;
int flg_end;
int num_country;
int num_bord;
int tab_bord_tempo[MAX_VECT];
int i,*p_alloc;
/* Vecteur courant */
VECT *V;
int num_vect,code;
BOOL Flg_Draw;
Flg_Err=TRUE;
num_country=0;
flg_end=FALSE;
#ifdef DRAW
r = rpG;
SetRast(r,COLOR_BLEU+num_first_color);
SetAPen(r,COLOR_COTE+num_first_color);
SetBPen(r,COLOR_COTE+num_first_color);
#endif
sprintf(Buffer_Name,"%s.zones",p_filename);
if (input = fopen(Buffer_Name,"r"))
{
do
{
/***************************************************/
/* D'abord le nom de la zone */
/* On alloue de la memoire pour sauvegarder ce nom */
/* et on le recopie */
/***************************************************/
Dtb_Init_Country(&tab_country[num_country]);
fscanf(input,"%d",&tab_country[num_country].continent);
/* Lecture du reste de la ligne */
P_Temp=fgets(str,100,input);
if(P_Temp!=NULL)
{
/* Enleve les blancs */
P_Temp=stpblk(P_Temp);
#ifdef TOMDEBUG
printf("Country name:%s\n",P_Temp);
#endif
/* Enleve le newline de fin de ligne */
P_Temp[strlen(P_Temp)-1]=0;
tab_country[num_country].name=strdup(P_Temp);
}
/* Debut du dessin */
flg_country=TRUE;
/************************************************/
/* On recupere les numeros de border de ce pays */
/* puis pour chaque bord on affiche ses vecteurs*/
/************************************************/
mx=100000;
my=100000;
MX=-100000;
MY=-100000;
num_bord=0;
code=0;
do
{
fscanf(input,"%d",&num_vect);
#ifdef TOMDEBUG
printf("Vecteur num:%d\n",num_vect);
#endif
tab_bord_tempo[num_bord]=num_vect;
V=tab_vect[num_vect].p_vect;
Flg_Draw=TRUE;
if(V[0].Code>1000)
{
code=V[0].Code/1000;
if((code==ID_LAC)||(code==ID_RIVIERES))
{
Flg_Draw=FALSE;
}
}
if(Flg_Draw)
{
for(i=0;i<tab_vect[num_vect].nb_vect;i++)
{
#ifdef DRAW
if(i==0)
{
MyMove(r,V[0].x,V[0].y);
}
else
{
MyDraw(r,V[i].x,V[i].y,V[i].Code);
}
#endif
tstpt(V[i].x,V[i].y,&mx,&my,&MX,&MY);
}
}
num_bord++;
if(num_bord>=MAX_VECT)
{
printf("ERROR:Max number of border exceeded\n");
flg_end=TRUE;
}
} while(tst_end(input)==FALSE);
if (MX<=mx)
{
mx=V[0].x-5;
MX=V[0].x+5;
}
if (MY<=my)
{
my=V[0].y-5;
MY=V[0].y+5;
}
tab_country[num_country].c_clip.minx=mx;
tab_country[num_country].c_clip.miny=my;
tab_country[num_country].c_clip.maxx=MX;
tab_country[num_country].c_clip.maxy=MY;
#ifdef DRAW
MyMove(r,mx,my);
MyDraw(r,MX,my,5);
MyDraw(r,MX,MY,5);
MyDraw(r,mx,MY,5);
MyDraw(r,mx,my,5);
#endif
/****************************************/
/* On sait le nombre de bord de ce pays */
/* on leur alloue de la memoire et on le*/
/* recopie */
/****************************************/
#ifdef DEBUG_TOM
printf("Il y a eu:%d bord\n",num_bord);
#endif
tab_country[num_country].nb_borders=num_bord;
p_alloc=(int *)malloc((10+num_bord)*sizeof(int));
tab_country[num_country].p_borders=p_alloc;
for(i=0;i<num_bord;i++)
{
*p_alloc=tab_bord_tempo[i];
/* printf("%d %d\n",i,tab_bord_tempo[i]);*/
p_alloc++;
}
num_country++;
if (num_country>=MAX_COUNTRY)
{
printf("ERROR:Max number of country excedeed\n");
flg_end=TRUE;
}
} while((tst_end(input)==FALSE)&&(flg_end==FALSE));
fclose(input);
Flg_Err=FALSE;
}
max_country=num_country;
return(Flg_Err);
}
///
/*********************************************************** save_zones() ***/
void
save_zones( char *p_filename)
{
FILE *output;
int num_country;
int i;
if (output = fopen(p_filename,"w"))
{
for(num_country=0;num_country<max_country;num_country++)
{
fprintf(output,"%d ",tab_country[num_country].continent);
fprintf(output,"%s\n",tab_country[num_country].name);
for(i=0;i<tab_country[num_country].nb_borders;i++)
{
fprintf(output,"%d ",tab_country[num_country].p_borders[i]);
}
fprintf(output,"E\n");
}
fclose(output);
}
}
void close_files(void)
{
if (bptr_big!=NULL)
Close(bptr_big);
}